Class AeSdkWallet

Contain functionality for aepp interaction and managing multiple aepps

Hierarchy

Constructors

constructor

Properties

_clients _getPollInterval _options _type accounts aensBid aensClaim aensPreclaim aensQuery aensRevoke aensTransfer aensUpdate awaitHeight buildAuthTxHash createGeneralizedAccount extendOracleTtl getAccount getBalance getContract getContractByteCode getCurrentGeneration getGeneration getHeight getKeyBlock getMicroBlockHeader getMicroBlockTransactions getName getOracleObject getQueryObject id name onAskAccounts onConnection onDisconnect onSubscription payForTransaction poll pollForQueries pollForQueryResponse pool postQueryToOracle registerOracle resolveName respondToQuery selectedAddress? selectedNodeName? send sendTransaction spend transferFunds txDryRun waitForTxConfirm

Accessors

address api compilerApi

Methods

_disconnectRpcClient _getClient _getNode _getOptions _isRpcClientConnected _isRpcClientSubscribed _pushAccountsToApps _resolveAccount addAccount addNode addRpcClient addresses buildTx ensureNodeConnected getAccounts getNodeInfo getNodesInPool getWalletInfo initializeContract isNodeConnected removeAccount removeRpcClient selectAccount selectNode shareWalletInfo sign signMessage signTransaction

Constructors

constructor

Properties

_clients

_clients: Map<string, RpcClientsInfo> = ...

_getPollInterval

_getPollInterval: ((...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => number)

Type declaration

    • (...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): number

    • Parameters

      • Rest ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns number

_options

_options: AeSdkMethodsOptions = ...

_type

_type: WALLET_TYPE

accounts

accounts: {
    [key: AccountAddress]: AccountBase;
} = {}

Type declaration

aensBid

aensBid: ((...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

    • (...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<AensClaimReturnType>

    • Parameters

      • Rest ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<AensClaimReturnType>

aensClaim

aensClaim: ((...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

aensPreclaim

aensPreclaim: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<SendReturnType & {
    claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
    commitmentId: string;
    height: number;
    salt: number;
}>>)

Type declaration

aensQuery

aensQuery: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
} & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
} & {
    extendTtl: ((nameTtl: number, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    id: `nm_${string}`;
    owner: `ak_${string}`;
    pointers: NamePointer[] | KeyPointers;
    revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType>);
    transfer: ((account: `ak_${string}`, options?: {
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    ttl: number;
    update: ((pointers: KeyPointers, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
}>>)

Type declaration

    • (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & {
          extendTtl: ((nameTtl: number, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          id: `nm_${string}`;
          owner: `ak_${string}`;
          pointers: NamePointer[] | KeyPointers;
          revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType>);
          transfer: ((account: `ak_${string}`, options?: {
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          ttl: number;
          update: ((pointers: KeyPointers, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      }>>

    • Parameters

      Returns Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & {
          extendTtl: ((nameTtl: number, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          id: `nm_${string}`;
          owner: `ak_${string}`;
          pointers: NamePointer[] | KeyPointers;
          revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType>);
          transfer: ((account: `ak_${string}`, options?: {
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          ttl: number;
          update: ((pointers: KeyPointers, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      }>>

aensRevoke

aensRevoke: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

aensTransfer

aensTransfer: ((...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

    • (...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<SendReturnType>

    • Parameters

      • Rest ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<SendReturnType>

aensUpdate

aensUpdate: ((...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

awaitHeight

awaitHeight: ((...args: [number] | [number, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

    • (...args: [number] | [number, Omit<{
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<number>

    • Parameters

      • Rest ...args: [number] | [number, Omit<{
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<number>

buildAuthTxHash

buildAuthTxHash: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Uint8Array>)

Type declaration

    • (...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<Uint8Array>

    • Parameters

      • Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<Uint8Array>

createGeneralizedAccount

createGeneralizedAccount: ((...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    gaContractId: `ct_${string}`;
    owner: `ak_${string}`;
    rawTx: `tx_${string}`;
    transaction: `th_${string}`;
}>>)

Type declaration

    • (...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<Readonly<{
          gaContractId: `ct_${string}`;
          owner: `ak_${string}`;
          rawTx: `tx_${string}`;
          transaction: `th_${string}`;
      }>>

    • Parameters

      Returns Promise<Readonly<{
          gaContractId: `ct_${string}`;
          owner: `ak_${string}`;
          rawTx: `tx_${string}`;
          transaction: `th_${string}`;
      }>>

extendOracleTtl

extendOracleTtl: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

getAccount

getAccount: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    authFun?: string;
    balance: bigint;
    contractId?: string;
    id: string;
    kind?: AccountKind;
    nonce: number;
    payable?: boolean;
}>)

Type declaration

    • (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
          hash?: `kh_${string}` | `mh_${string}`;
          height?: number;
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          authFun?: string;
          balance: bigint;
          contractId?: string;
          id: string;
          kind?: AccountKind;
          nonce: number;
          payable?: boolean;
      }>

    • Parameters

      • Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
            hash?: `kh_${string}` | `mh_${string}`;
            height?: number;
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          authFun?: string;
          balance: bigint;
          contractId?: string;
          id: string;
          kind?: AccountKind;
          nonce: number;
          payable?: boolean;
      }>

getBalance

getBalance: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    format?: AE_AMOUNT_FORMATS;
} & {
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

    • (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
          format?: AE_AMOUNT_FORMATS;
      } & {
          hash?: `kh_${string}` | `mh_${string}`;
          height?: number;
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<string>

    • Parameters

      • Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
            format?: AE_AMOUNT_FORMATS;
        } & {
            hash?: `kh_${string}` | `mh_${string}`;
            height?: number;
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<string>

getContract

getContract: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    abiVersion: string;
    active: boolean;
    deposit: bigint;
    id: string;
    ownerId: string;
    referrerIds: string[];
    vmVersion: string;
}>)

Type declaration

    • (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          abiVersion: string;
          active: boolean;
          deposit: bigint;
          id: string;
          ownerId: string;
          referrerIds: string[];
          vmVersion: string;
      }>

    • Parameters

      • Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          abiVersion: string;
          active: boolean;
          deposit: bigint;
          id: string;
          ownerId: string;
          referrerIds: string[];
          vmVersion: string;
      }>

getContractByteCode

getContractByteCode: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    bytecode: `cb_${string}`;
}>)

Type declaration

    • (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          bytecode: `cb_${string}`;
      }>

    • Parameters

      • Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          bytecode: `cb_${string}`;
      }>

getCurrentGeneration

getCurrentGeneration: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

    • (...args: [] | [Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>

    • Parameters

      • Rest ...args: [] | [Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>

getGeneration

getGeneration: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

    • (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>

    • Parameters

      • Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>

getHeight

getHeight: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

    • (...args: [] | [Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<number>

    • Parameters

      • Rest ...args: [] | [Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<number>

getKeyBlock

getKeyBlock: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    beneficiary: string;
    hash: string;
    height: number;
    info: string;
    miner: string;
    nonce?: number;
    pow?: string[];
    prevHash: string;
    prevKeyHash: string;
    stateHash: string;
    target: string;
    time: number;
    version: number;
}>)

Type declaration

    • (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          beneficiary: string;
          hash: string;
          height: number;
          info: string;
          miner: string;
          nonce?: number;
          pow?: string[];
          prevHash: string;
          prevKeyHash: string;
          stateHash: string;
          target: string;
          time: number;
          version: number;
      }>

    • Parameters

      • Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          beneficiary: string;
          hash: string;
          height: number;
          info: string;
          miner: string;
          nonce?: number;
          pow?: string[];
          prevHash: string;
          prevKeyHash: string;
          stateHash: string;
          target: string;
          time: number;
          version: number;
      }>

getMicroBlockHeader

getMicroBlockHeader: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    hash: string;
    height: number;
    pofHash: string;
    prevHash: string;
    prevKeyHash: string;
    signature: string;
    stateHash: string;
    time: number;
    txsHash: string;
    version: number;
}>)

Type declaration

    • (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          hash: string;
          height: number;
          pofHash: string;
          prevHash: string;
          prevKeyHash: string;
          signature: string;
          stateHash: string;
          time: number;
          txsHash: string;
          version: number;
      }>

    • Parameters

      • Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          hash: string;
          height: number;
          pofHash: string;
          prevHash: string;
          prevKeyHash: string;
          signature: string;
          stateHash: string;
          time: number;
          txsHash: string;
          version: number;
      }>

getMicroBlockTransactions

getMicroBlockTransactions: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}[]>)

Type declaration

    • (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }[]>

    • Parameters

      • Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }[]>

getName

getName: ((...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
}>)

Type declaration

    • (...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      }>

    • Parameters

      • Rest ...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      }>

getOracleObject

getOracleObject: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
    onAccount: AccountBase;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetOracleObjectReturnType>)

Type declaration

getQueryObject

getQueryObject: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetQueryObjectReturnType>)

Type declaration

    • (...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<GetQueryObjectReturnType>

    • Parameters

      • Rest ...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<GetQueryObjectReturnType>

id

id: string

name

name: string

onAskAccounts

onAskAccounts: OnAskAccounts

onConnection

onConnection: OnConnection

onDisconnect

onDisconnect: OnDisconnect

onSubscription

onSubscription: OnSubscription

payForTransaction

payForTransaction: ((...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

poll

poll: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    blocks?: number;
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}>)

Type declaration

    • (...args: [`th_${string}`] | [`th_${string}`, Omit<{
          blocks?: number;
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }>

    • Parameters

      • Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
            blocks?: number;
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }>

pollForQueries

pollForQueries: ((...args: [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void)] | [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void), Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => (() => void))

Type declaration

    • (...args: [`ok_${string}`, ((queries: {
          fee: bigint;
          id: string;
          oracleId: string;
          query: string;
          response: string;
          responseTtl: { type: TTLType; value: string; };
          senderId: string;
          senderNonce: string;
          ttl: number;
      }[]) => void)] | [`ok_${string}`, ((queries: {
          fee: bigint;
          id: string;
          oracleId: string;
          query: string;
          response: string;
          responseTtl: { type: TTLType; value: string; };
          senderId: string;
          senderNonce: string;
          ttl: number;
      }[]) => void), Omit<{
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): (() => void)

    • Parameters

      • Rest ...args: [`ok_${string}`, ((queries: {
            fee: bigint;
            id: string;
            oracleId: string;
            query: string;
            response: string;
            responseTtl: { type: TTLType; value: string; };
            senderId: string;
            senderNonce: string;
            ttl: number;
        }[]) => void)] | [`ok_${string}`, ((queries: {
            fee: bigint;
            id: string;
            oracleId: string;
            query: string;
            response: string;
            responseTtl: { type: TTLType; value: string; };
            senderId: string;
            senderNonce: string;
            ttl: number;
        }[]) => void), Omit<{
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns (() => void)

        • (): void

        • Poll for oracle queries

          Category

          oracle

          Returns

          Callback to stop polling function

          Returns void

pollForQueryResponse

pollForQueryResponse: ((...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

    • (...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<string>

    • Parameters

      • Rest ...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<string>

pool

pool: Map<string, Node> = ...

postQueryToOracle

postQueryToOracle: ((...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetQueryObjectReturnType>)

Type declaration

registerOracle

registerOracle: ((...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

resolveName

resolveName: ((...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
    onNode: Node;
    resolveByNode?: boolean;
    verify?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>)

Type declaration

    • (...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
          onNode: Node;
          resolveByNode?: boolean;
          verify?: boolean;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>

    • Parameters

      • Rest ...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
            onNode: Node;
            resolveByNode?: boolean;
            verify?: boolean;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>

respondToQuery

respondToQuery: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

Optional selectedAddress

selectedAddress?: `ak_${string}`

Optional selectedNodeName

selectedNodeName?: string

send

send: ((...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

sendTransaction

sendTransaction: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendTransactionReturnType>)

Type declaration

spend

spend: ((...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

    • (...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<SendReturnType>

    • Parameters

      • Rest ...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<SendReturnType>

transferFunds

transferFunds: ((...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

    • (...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<SendReturnType>

    • Parameters

      • Rest ...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<SendReturnType>

txDryRun

txDryRun: ((...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
    combine?: boolean;
    onNode: Node;
    top?: number | `kh_${string}` | `mh_${string}`;
    txEvents?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    txEvents?: {}[];
} & {
    callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
    reason?: string;
    result: string;
    type: string;
}>)

Type declaration

    • (...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
          combine?: boolean;
          onNode: Node;
          top?: number | `kh_${string}` | `mh_${string}`;
          txEvents?: boolean;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          txEvents?: {}[];
      } & {
          callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
          reason?: string;
          result: string;
          type: string;
      }>

    • Parameters

      • Rest ...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
            combine?: boolean;
            onNode: Node;
            top?: number | `kh_${string}` | `mh_${string}`;
            txEvents?: boolean;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          txEvents?: {}[];
      } & {
          callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
          reason?: string;
          result: string;
          type: string;
      }>

waitForTxConfirm

waitForTxConfirm: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    confirm?: number;
    onNode: Node;
} & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

    • (...args: [`th_${string}`] | [`th_${string}`, Omit<{
          confirm?: number;
          onNode: Node;
      } & {
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<number>

    • Parameters

      • Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
            confirm?: number;
            onNode: Node;
        } & {
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<number>

Accessors

address

  • get address(): `ak_${string}`

  • Returns `ak_${string}`

api

compilerApi

Methods

_disconnectRpcClient

  • _disconnectRpcClient(clientId: string): void

  • Parameters

    • clientId: string

    Returns void

_getClient

_getNode

_getOptions

_isRpcClientConnected

  • _isRpcClientConnected(clientId: string): boolean

  • Parameters

    • clientId: string

    Returns boolean

_isRpcClientSubscribed

  • _isRpcClientSubscribed(clientId: string): boolean

  • Parameters

    • clientId: string

    Returns boolean

_pushAccountsToApps

_resolveAccount

addAccount

  • Add specific account

    Example

    addAccount(account)

    Parameters

    • account: AccountBase

      Account instance

    • Optional options: {
          select?: boolean;
      }

      Options

      • Optional select?: boolean

    Returns void

addNode

  • Add Node

    Example

    // add and select new node with name 'testNode'
    aeSdkBase.addNode('testNode', new Node({ url }), true)

    Parameters

    • name: string

      Node name

    • node: Node

      Node instance

    • select: boolean = false

      Select this node as current

    Returns void

addRpcClient

  • Add new client by AEPP connection

    Returns

    Client ID

    Parameters

    • clientConnection: default

      AEPP connection object

    Returns string

addresses

  • Get accounts addresses

    Example

    addresses()

    Returns `ak_${string}`[]

buildTx

  • Type Parameters

    • TxType extends Tag

    Parameters

    • txType: TxType
    • options: Omit<Omit<{
          tag: TxType;
          version?: Extract<KeysOfUnion<{
              10: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Account);
                      serialize: ((value?: Account) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["balance", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Account);
                      serialize: ((value?: Account) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["flags", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["balance", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["gaContract", {
                      deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                      serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["gaAuthFun", binary, ContractBytearray]];
              };
              11: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => SignedTx);
                      serialize: ((value?: SignedTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["signatures", signatures], readonly ["encodedTx", rlpBinary]];
              };
              12: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => SpendTx);
                      serialize: ((value?: SpendTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["senderId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["recipientId", {
                      deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                      serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["payload", payload]];
              };
              20: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Oracle);
                      serialize: ((value?: Oracle) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["oracleTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["abiVersion", {
                      deserialize: ((value: Buffer) => ABI_VERSIONS);
                      serialize: ((value: ABI_VERSIONS) => Buffer);
                  }]];
              };
              22: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleRegisterTx);
                      serialize: ((value?: OracleRegisterTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["oracleTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["oracleTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["abiVersion", {
                      deserialize: ((value: Buffer) => ABI_VERSIONS);
                      serialize: ((value: ABI_VERSIONS) => Buffer);
                  }]];
              };
              23: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleQueryTx);
                      serialize: ((value?: OracleQueryTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["senderId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["oracleId", {
                      deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                      serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["query", string], readonly ["queryFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["queryTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["queryTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["responseTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["responseTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              24: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleResponseTx);
                      serialize: ((value?: OracleResponseTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["oracleId", {
                      deserialize: ((value: Buffer) => `ok_${string}`);
                      serialize: ((value: `ok_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["queryId", binary, OracleQueryId], readonly ["response", string], readonly ["responseTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["responseTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              25: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleExtendTx);
                      serialize: ((value?: OracleExtendTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["oracleId", {
                      deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                      serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["oracleTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["oracleTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              30: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Name);
                      serialize: ((value?: Name) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nameTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["status", binary], readonly ["clientTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["pointers", {
                      deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                      serialize(pointers: NamePointer[]): Buffer[][];
                  }]];
              };
              32: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameClaimTx);
                      serialize: ((value?: NameClaimTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["name", {
                      deserialize(value: Buffer): `${string}.chain`;
                      serialize(value: `${string}.chain`): Buffer;
                  }], readonly ["nameSalt", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["nameFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, txFields: {
                          name: `${string}.chain`;
                      } & Options): Buffer;
                      serializeAettos(_value: undefined | string, txFields: {
                          name: `${string}.chain`;
                      }): string;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              33: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NamePreclaimTx);
                      serialize: ((value?: NamePreclaimTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["commitmentId", {
                      deserialize: ((value: Buffer) => `cm_${string}`);
                      serialize: ((value: `cm_${string}`) => Buffer);
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              34: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameUpdateTx);
                      serialize: ((value?: NameUpdateTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nameId", {
                      deserialize: ((value: Buffer) => `nm_${string}`);
                      serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
                  }], readonly ["nameTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["pointers", {
                      deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                      serialize(pointers: NamePointer[]): Buffer[][];
                  }], readonly ["clientTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              35: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameRevokeTx);
                      serialize: ((value?: NameRevokeTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nameId", {
                      deserialize: ((value: Buffer) => `nm_${string}`);
                      serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              36: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameTransferTx);
                      serialize: ((value?: NameTransferTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nameId", {
                      deserialize: ((value: Buffer) => `nm_${string}`);
                      serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
                  }], readonly ["recipientId", {
                      deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                      serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              40: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Contract);
                      serialize: ((value?: Contract) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["owner", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["log", binary, ContractBytearray], readonly ["active", bool], readonly ["referers", {
                      deserialize: ((value: Buffer[]) => `ak_${string}`[]);
                      serialize: ((value: `ak_${string}`[]) => Buffer[]);
                  }], readonly ["deposit", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, options: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }]];
              };
              41: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractCall);
                      serialize: ((value?: ContractCall) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["callerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["callerNonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["height", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["contractId", {
                      deserialize: ((value: Buffer) => `ct_${string}`);
                      serialize: ((value: `ct_${string}`) => Buffer);
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["gasUsed", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["returnValue", binary, ContractBytearray], readonly ["returnType", {
                      deserialize: ((value: Buffer) => CallReturnType);
                      serialize: ((value: CallReturnType) => Buffer);
                  }], readonly ["log", rawBinary]];
              };
              42: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractCreateTx);
                      serialize: ((value?: ContractCreateTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["ownerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["code", binary, ContractBytearray], readonly ["ctVersion", ctVersion], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["deposit", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, options: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["callData", binary, ContractBytearray]];
              };
              43: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractCallTx);
                      serialize: ((value?: ContractCallTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["callerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["contractId", {
                      deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                      serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["abiVersion", {
                      deserialize: ((value: Buffer) => ABI_VERSIONS);
                      serialize: ((value: ABI_VERSIONS) => Buffer);
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["callData", binary, ContractBytearray]];
              };
              50: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelCreateTx);
                      serialize: ((value?: ChannelCreateTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["initiator", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["initiatorAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responder", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["responderAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["channelReserve", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["lockPeriod", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["initiatorDelegateIds", string], readonly ["responderDelegateIds", string], readonly ["stateHash", binary, State], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              51: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelDepositTx);
                      serialize: ((value?: ChannelDepositTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["stateHash", binary, State], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              52: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelWithdrawTx);
                      serialize: ((value?: ChannelWithdrawTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["toId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["stateHash", binary, State], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              521: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelForceProgressTx);
                      serialize: ((value?: ChannelForceProgressTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", binary, Transaction], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["update", binary, ContractBytearray], readonly ["stateHash", binary, State], readonly ["offChainTrees", stateTree], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              53: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                      serialize: ((value?: ChannelCloseMutualTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["initiatorAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responderAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              54: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                      serialize: ((value?: ChannelCloseSoloTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", binary, Transaction], readonly ["poi", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => TxUnpacked<Partial<Pick<{
                          version: undefined | 1;
                      }, "version">> & Omit<{
                          version: undefined | 1;
                      }, "version"> & Partial<Pick<{
                          tag: undefined | TreesPoi;
                      }, "tag">> & Omit<{
                          tag: undefined | TreesPoi;
                      }, "tag"> & Partial<Pick<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never>> & Omit<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never> & Partial<Pick<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never>> & Omit<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never> & Partial<Pick<{
                          channels: MPTree<Channel, Channel>[];
                      }, never>> & Omit<{
                          channels: MPTree<Channel, Channel>[];
                      }, never> & Partial<Pick<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never>> & Omit<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never> & Partial<Pick<{
                          ns: MPTree<Name, Name>[];
                      }, never>> & Omit<{
                          ns: MPTree<Name, Name>[];
                      }, never> & Partial<Pick<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>> & Omit<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>>);
                      serialize: ((value: ({ tag: Tag.TreesPoi; version?: 1 | undefined; }) & Omit<Partial<Pick<{
                          version: undefined | 1;
                      }, "version">> & Omit<{
                          version: undefined | 1;
                      }, "version"> & Partial<Pick<{
                          tag: undefined | TreesPoi;
                      }, "tag">> & Omit<{
                          tag: undefined | TreesPoi;
                      }, "tag"> & Partial<Pick<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never>> & Omit<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never> & Partial<Pick<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never>> & Omit<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never> & Partial<Pick<{
                          channels: MPTree<Channel, Channel>[];
                      }, never>> & Omit<{
                          channels: MPTree<Channel, Channel>[];
                      }, never> & Partial<Pick<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never>> & Omit<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never> & Partial<Pick<{
                          ns: MPTree<Name, Name>[];
                      }, never>> & Omit<{
                          ns: MPTree<Name, Name>[];
                      }, never> & Partial<Pick<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>> & Omit<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>, "version" | "tag">, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              55: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelSlashTx);
                      serialize: ((value?: ChannelSlashTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", binary, Transaction], readonly ["poi", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => TxUnpacked<Partial<Pick<{
                          version: undefined | 1;
                      }, "version">> & Omit<{
                          version: undefined | 1;
                      }, "version"> & Partial<Pick<{
                          tag: undefined | TreesPoi;
                      }, "tag">> & Omit<{
                          tag: undefined | TreesPoi;
                      }, "tag"> & Partial<Pick<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never>> & Omit<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never> & Partial<Pick<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never>> & Omit<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never> & Partial<Pick<{
                          channels: MPTree<Channel, Channel>[];
                      }, never>> & Omit<{
                          channels: MPTree<Channel, Channel>[];
                      }, never> & Partial<Pick<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never>> & Omit<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never> & Partial<Pick<{
                          ns: MPTree<Name, Name>[];
                      }, never>> & Omit<{
                          ns: MPTree<Name, Name>[];
                      }, never> & Partial<Pick<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>> & Omit<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>>);
                      serialize: ((value: ({ tag: Tag.TreesPoi; version?: 1 | undefined; }) & Omit<Partial<Pick<{
                          version: undefined | 1;
                      }, "version">> & Omit<{
                          version: undefined | 1;
                      }, "version"> & Partial<Pick<{
                          tag: undefined | TreesPoi;
                      }, "tag">> & Omit<{
                          tag: undefined | TreesPoi;
                      }, "tag"> & Partial<Pick<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never>> & Omit<{
                          accounts: MPTree<AccountAddress, Account>[];
                      }, never> & Partial<Pick<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never>> & Omit<{
                          calls: MPTree<Bytearray, ContractCall>[];
                      }, never> & Partial<Pick<{
                          channels: MPTree<Channel, Channel>[];
                      }, never>> & Omit<{
                          channels: MPTree<Channel, Channel>[];
                      }, never> & Partial<Pick<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never>> & Omit<{
                          contracts: MPTree<ContractAddress, Contract>[];
                      }, never> & Partial<Pick<{
                          ns: MPTree<Name, Name>[];
                      }, never>> & Omit<{
                          ns: MPTree<Name, Name>[];
                      }, never> & Partial<Pick<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>> & Omit<{
                          oracles: MPTree<OracleAddress, Oracle>[];
                      }, never>, "version" | "tag">, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              56: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelSettleTx);
                      serialize: ((value?: ChannelSettleTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["initiatorAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responderAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              57: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainTx);
                      serialize: ((value?: ChannelOffChainTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["stateHash", binary, State]];
              };
              570: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                      serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["from", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["to", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
              };
              571: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                      serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["from", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
              };
              572: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                      serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["from", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
              };
              573: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                      serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["owner", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["deposit", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["callData", binary, ContractBytearray]];
              };
              574: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                      serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["caller", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["contract", {
                      deserialize: ((value: Buffer) => `ct_${string}`);
                      serialize: ((value: `ct_${string}`) => Buffer);
                  }], readonly ["abiVersion", {
                      deserialize: ((value: Buffer) => ABI_VERSIONS);
                      serialize: ((value: ABI_VERSIONS) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["callData", binary, ContractBytearray], readonly ["callStack", callStack], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }]];
              };
              575: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                      serialize: ((value?: ChannelClientReconnectTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["role", string], readonly ["pubkey", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }]];
              };
              58: {
                  3: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Channel);
                      serialize: ((value?: Channel) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 3);
                      serialize: ((value?: 3) => Buffer);
                  }], readonly ["initiator", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["responder", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["channelAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["initiatorAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responderAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["channelReserve", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["initiatorDelegateIds", {
                      deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                      serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
                  }], readonly ["responderDelegateIds", {
                      deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                      serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
                  }], readonly ["stateHash", hex], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["soloRound", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["lockPeriod", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["lockedUntil", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["initiatorAuth", binary, ContractBytearray], readonly ["responderAuth", binary, ContractBytearray]];
              };
              59: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                      serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", binary, Transaction], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              60: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => TreesPoi);
                      serialize: ((value?: TreesPoi) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accounts", {
                      deserialize: ((value: MPTreeBinary[], o: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => MPTree<AccountAddress, Account>[]);
                      serialize: ((value: MPTree<AccountAddress, Account>[]) => MPTreeBinary[]);
                  }], readonly ["calls", {
                      deserialize: ((value: MPTreeBinary[], o: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => MPTree<Bytearray, ContractCall>[]);
                      serialize: ((value: MPTree<Bytearray, ContractCall>[]) => MPTreeBinary[]);
                  }], readonly ["channels", {
                      deserialize: ((value: MPTreeBinary[], o: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => MPTree<Channel, Channel>[]);
                      serialize: ((value: MPTree<Channel, Channel>[]) => MPTreeBinary[]);
                  }], readonly ["contracts", {
                      deserialize: ((value: MPTreeBinary[], o: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => MPTree<ContractAddress, Contract>[]);
                      serialize: ((value: MPTree<ContractAddress, Contract>[]) => MPTreeBinary[]);
                  }], readonly ["ns", {
                      deserialize: ((value: MPTreeBinary[], o: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => MPTree<Name, Name>[]);
                      serialize: ((value: MPTree<Name, Name>[]) => MPTreeBinary[]);
                  }], readonly ["oracles", {
                      deserialize: ((value: MPTreeBinary[], o: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }) => MPTree<OracleAddress, Oracle>[]);
                      serialize: ((value: MPTree<OracleAddress, Oracle>[]) => MPTreeBinary[]);
                  }]];
              };
              62: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => StateTrees);
                      serialize: ((value?: StateTrees) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["contracts", rlpBinary], readonly ["calls", rlpBinary], readonly ["channels", rlpBinary], readonly ["ns", rlpBinary], readonly ["oracles", rlpBinary], readonly ["accounts", rlpBinary]];
              };
              621: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractsMtree);
                      serialize: ((value?: ContractsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["contracts", rlpBinary]];
              };
              622: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => CallsMtree);
                      serialize: ((value?: CallsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["calls", rlpBinary]];
              };
              623: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelsMtree);
                      serialize: ((value?: ChannelsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channels", rlpBinary]];
              };
              624: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameserviceMtree);
                      serialize: ((value?: NameserviceMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["mtree", rlpBinary]];
              };
              625: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OraclesMtree);
                      serialize: ((value?: OraclesMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["otree", rlpBinary]];
              };
              626: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => AccountsMtree);
                      serialize: ((value?: AccountsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accounts", rlpBinary]];
              };
              63: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Mtree);
                      serialize: ((value?: Mtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["values", rlpBinaries]];
              };
              64: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => MtreeValue);
                      serialize: ((value?: MtreeValue) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["key", hex], readonly ["value", rawBinary]];
              };
              70: {
                  3: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => CompilerSophia);
                      serialize: ((value?: CompilerSophia) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 3);
                      serialize: ((value?: 3) => Buffer);
                  }], readonly ["sourceCodeHash", rawBinary], readonly ["typeInfo", sophiaCodeTypeInfo], readonly ["byteCode", rawBinary], readonly ["compilerVersion", string], readonly ["payable", bool]];
              };
              80: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => GaAttachTx);
                      serialize: ((value?: GaAttachTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["ownerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["code", binary, ContractBytearray], readonly ["authFun", rawBinary], readonly ["ctVersion", ctVersion], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["callData", binary, ContractBytearray]];
              };
              81: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => GaMetaTx);
                      serialize: ((value?: GaMetaTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["gaId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["authData", binary, ContractBytearray], readonly ["abiVersion", {
                      deserialize: ((value: Buffer) => ABI_VERSIONS);
                      serialize: ((value: ABI_VERSIONS) => Buffer);
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["tx", rlpBinary]];
              };
              82: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => PayingForTx);
                      serialize: ((value?: PayingForTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["payerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["tx", rlpBinary]];
              };
          }[TxType]>, number>;
      } & Omit<TxTypeSchemaBy<TxType, Extract<KeysOfUnion<{
          10: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["flags", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["gaContract", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["gaAuthFun", binary, ContractBytearray]];
          };
          11: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SignedTx);
                  serialize: ((value?: SignedTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["signatures", signatures], readonly ["encodedTx", rlpBinary]];
          };
          12: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SpendTx);
                  serialize: ((value?: SpendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["payload", payload]];
          };
          20: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Oracle);
                  serialize: ((value?: Oracle) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }]];
          };
          22: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleRegisterTx);
                  serialize: ((value?: OracleRegisterTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }]];
          };
          23: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleQueryTx);
                  serialize: ((value?: OracleQueryTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["query", string], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["queryTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["queryTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          24: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleResponseTx);
                  serialize: ((value?: OracleResponseTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}`);
                  serialize: ((value: `ok_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryId", binary, OracleQueryId], readonly ["response", string], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          25: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleExtendTx);
                  serialize: ((value?: OracleExtendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          30: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Name);
                  serialize: ((value?: Name) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["status", binary], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }]];
          };
          32: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameClaimTx);
                  serialize: ((value?: NameClaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["name", {
                  deserialize(value: Buffer): `${string}.chain`;
                  serialize(value: `${string}.chain`): Buffer;
              }], readonly ["nameSalt", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nameFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, txFields: {
                      name: `${string}.chain`;
                  } & Options): Buffer;
                  serializeAettos(_value: undefined | string, txFields: {
                      name: `${string}.chain`;
                  }): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          33: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NamePreclaimTx);
                  serialize: ((value?: NamePreclaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["commitmentId", {
                  deserialize: ((value: Buffer) => `cm_${string}`);
                  serialize: ((value: `cm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          34: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameUpdateTx);
                  serialize: ((value?: NameUpdateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          35: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameRevokeTx);
                  serialize: ((value?: NameRevokeTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          36: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameTransferTx);
                  serialize: ((value?: NameTransferTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          40: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Contract);
                  serialize: ((value?: Contract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["log", binary, ContractBytearray], readonly ["active", bool], readonly ["referers", {
                  deserialize: ((value: Buffer[]) => `ak_${string}`[]);
                  serialize: ((value: `ak_${string}`[]) => Buffer[]);
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }]];
          };
          41: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCall);
                  serialize: ((value?: ContractCall) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["callerNonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["height", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasUsed", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["returnValue", binary, ContractBytearray], readonly ["returnType", {
                  deserialize: ((value: Buffer) => CallReturnType);
                  serialize: ((value: CallReturnType) => Buffer);
              }], readonly ["log", rawBinary]];
          };
          42: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCreateTx);
                  serialize: ((value?: ContractCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", binary, ContractBytearray], readonly ["ctVersion", ctVersion], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          43: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCallTx);
                  serialize: ((value?: ContractCallTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          50: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCreateTx);
                  serialize: ((value?: ChannelCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["initiatorDelegateIds", string], readonly ["responderDelegateIds", string], readonly ["stateHash", binary, State], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          51: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelDepositTx);
                  serialize: ((value?: ChannelDepositTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", binary, State], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          52: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelWithdrawTx);
                  serialize: ((value?: ChannelWithdrawTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["toId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", binary, State], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          521: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelForceProgressTx);
                  serialize: ((value?: ChannelForceProgressTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["update", binary, ContractBytearray], readonly ["stateHash", binary, State], readonly ["offChainTrees", stateTree], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          53: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                  serialize: ((value?: ChannelCloseMutualTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          54: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                  serialize: ((value?: ChannelCloseSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => TxUnpacked<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>>);
                  serialize: ((value: {
                      tag: TreesPoi;
                      version?: 1;
                  } & Omit<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>, "version" | "tag">, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          55: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSlashTx);
                  serialize: ((value?: ChannelSlashTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => TxUnpacked<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>>);
                  serialize: ((value: {
                      tag: TreesPoi;
                      version?: 1;
                  } & Omit<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>, "version" | "tag">, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          56: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSettleTx);
                  serialize: ((value?: ChannelSettleTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          57: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainTx);
                  serialize: ((value?: ChannelOffChainTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["stateHash", binary, State]];
          };
          570: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                  serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["to", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          571: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                  serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          572: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                  serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          573: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                  serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          574: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                  serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["caller", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["contract", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", binary, ContractBytearray], readonly ["callStack", callStack], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }]];
          };
          575: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                  serialize: ((value?: ChannelClientReconnectTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["role", string], readonly ["pubkey", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }]];
          };
          58: {
              3: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Channel);
                  serialize: ((value?: Channel) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 3);
                  serialize: ((value?: 3) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["channelAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorDelegateIds", {
                  deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
              }], readonly ["responderDelegateIds", {
                  deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
              }], readonly ["stateHash", hex], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["soloRound", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockedUntil", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAuth", binary, ContractBytearray], readonly ["responderAuth", binary, ContractBytearray]];
          };
          59: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                  serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          60: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => TreesPoi);
                  serialize: ((value?: TreesPoi) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<AccountAddress, Account>[]);
                  serialize: ((value: MPTree<AccountAddress, Account>[]) => MPTreeBinary[]);
              }], readonly ["calls", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<Bytearray, ContractCall>[]);
                  serialize: ((value: MPTree<Bytearray, ContractCall>[]) => MPTreeBinary[]);
              }], readonly ["channels", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<Channel, Channel>[]);
                  serialize: ((value: MPTree<Channel, Channel>[]) => MPTreeBinary[]);
              }], readonly ["contracts", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<ContractAddress, Contract>[]);
                  serialize: ((value: MPTree<ContractAddress, Contract>[]) => MPTreeBinary[]);
              }], readonly ["ns", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<Name, Name>[]);
                  serialize: ((value: MPTree<Name, Name>[]) => MPTreeBinary[]);
              }], readonly ["oracles", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<OracleAddress, Oracle>[]);
                  serialize: ((value: MPTree<OracleAddress, Oracle>[]) => MPTreeBinary[]);
              }]];
          };
          62: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => StateTrees);
                  serialize: ((value?: StateTrees) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", rlpBinary], readonly ["calls", rlpBinary], readonly ["channels", rlpBinary], readonly ["ns", rlpBinary], readonly ["oracles", rlpBinary], readonly ["accounts", rlpBinary]];
          };
          621: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractsMtree);
                  serialize: ((value?: ContractsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", rlpBinary]];
          };
          622: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => CallsMtree);
                  serialize: ((value?: CallsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["calls", rlpBinary]];
          };
          623: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelsMtree);
                  serialize: ((value?: ChannelsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channels", rlpBinary]];
          };
          624: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameserviceMtree);
                  serialize: ((value?: NameserviceMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["mtree", rlpBinary]];
          };
          625: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OraclesMtree);
                  serialize: ((value?: OraclesMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["otree", rlpBinary]];
          };
          626: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => AccountsMtree);
                  serialize: ((value?: AccountsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", rlpBinary]];
          };
          63: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Mtree);
                  serialize: ((value?: Mtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["values", rlpBinaries]];
          };
          64: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => MtreeValue);
                  serialize: ((value?: MtreeValue) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["key", hex], readonly ["value", rawBinary]];
          };
          70: {
              3: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => CompilerSophia);
                  serialize: ((value?: CompilerSophia) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 3);
                  serialize: ((value?: 3) => Buffer);
              }], readonly ["sourceCodeHash", rawBinary], readonly ["typeInfo", sophiaCodeTypeInfo], readonly ["byteCode", rawBinary], readonly ["compilerVersion", string], readonly ["payable", bool]];
          };
          80: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaAttachTx);
                  serialize: ((value?: GaAttachTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", binary, ContractBytearray], readonly ["authFun", rawBinary], readonly ["ctVersion", ctVersion], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          81: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaMetaTx);
                  serialize: ((value?: GaMetaTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["gaId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["authData", binary, ContractBytearray], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["tx", rlpBinary]];
          };
          82: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => PayingForTx);
                  serialize: ((value?: PayingForTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["payerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["tx", rlpBinary]];
          };
      }[TxType]>, number>>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
          gasMax?: number;
      } : {}), "nonce" | "ttl" | "abiVersion" | "tag" | "ctVersion"> & {
          denomination?: AE_AMOUNT_FORMATS;
      } & Omit<{
          absoluteTtl?: boolean;
          onNode: Node;
          senderId: `ak_${string}`;
          strategy?: "max" | "continuity";
      } & Pick<Partial<Partial<Pick<{
          tag: undefined | Account;
      }, "tag">> & Omit<{
          tag: undefined | Account;
      }, "tag"> & Partial<Pick<{
          nonce: number;
      }, never>> & Omit<{
          nonce: number;
      }, never> & Partial<Pick<{
          balance: Int;
      }, never>> & Omit<{
          balance: Int;
      }, never> & Partial<Pick<{
          version: undefined | 2;
      }, "version">> & Omit<{
          version: undefined | 2;
      }, "version"> & Partial<Pick<{
          flags: Int;
      }, never>> & Omit<{
          flags: Int;
      }, never> & Partial<Pick<{
          gaContract: `ct_${string}` | `nm_${string}`;
      }, never>> & Omit<{
          gaContract: `ct_${string}` | `nm_${string}`;
      }, never> & Partial<Pick<{
          gaAuthFun: `cb_${string}`;
      }, never>> & Omit<{
          gaAuthFun: `cb_${string}`;
      }, never> & Partial<Pick<{
          version: undefined | 1;
      }, "version">> & Omit<{
          version: undefined | 1;
      }, "version"> & Partial<Pick<{
          tag: undefined | SignedTx;
      }, "tag">> & Omit<{
          tag: undefined | SignedTx;
      }, "tag"> & Partial<Pick<{
          signatures: Uint8Array[];
      }, never>> & Omit<{
          signatures: Uint8Array[];
      }, never> & Partial<Pick<{
          encodedTx: any;
      }, "encodedTx">> & Omit<{
          encodedTx: any;
      }, "encodedTx"> & Partial<Pick<{
          tag: undefined | SpendTx;
      }, "tag">> & Omit<{
          tag: undefined | SpendTx;
      }, "tag"> & Partial<Pick<{
          senderId: `ak_${string}`;
      }, never>> & Omit<{
          senderId: `ak_${string}`;
      }, never> & Partial<Pick<{
          recipientId: `ak_${string}` | `nm_${string}`;
      }, never>> & Omit<{
          recipientId: `ak_${string}` | `nm_${string}`;
      }, never> & Partial<Pick<{
          amount: undefined | Int;
      }, "amount">> & Omit<{
          amount: undefined | Int;
      }, "amount"> & Partial<Pick<{
          fee: undefined | Int;
      }, "fee">> & Omit<{
          fee: undefined | Int;
      }, "fee"> & Partial<Pick<{
          ttl: number;
      }, never>> & Omit<{
          ttl: number;
      }, never> & Partial<Pick<{
          payload: undefined | string;
      }, "payload">> & Omit<{
          payload: undefined | string;
      }, "payload"> & Partial<Pick<{
          accountId: `ak_${string}`;
      }, never>> & Omit<{
          accountId: `ak_${string}`;
      }, never> & Partial<Pick<{
          abiVersion: ABI_VERSIONS;
      }, never>> & Omit<{
          abiVersion: ABI_VERSIONS;
      }, never> & Partial<Pick<{
          tag: undefined | Oracle;
      }, "tag">> & Omit<{
          tag: undefined | Oracle;
      }, "tag"> & Partial<Pick<{
          queryFormat: string;
      }, never>> & Omit<{
          queryFormat: string;
      }, never> & Partial<Pick<{
          responseFormat: string;
      }, never>> & Omit<{
          responseFormat: string;
      }, never> & Partial<Pick<{
          queryFee: undefined | Int;
      }, "queryFee">> & Omit<{
          queryFee: undefined | Int;
      }, "queryFee"> & Partial<Pick<{
          oracleTtlValue: number;
      }, never>> & Omit<{
          oracleTtlValue: number;
      }, never> & Partial<Pick<{
          tag: undefined | OracleRegisterTx;
      }, "tag">> & Omit<{
          tag: undefined | OracleRegisterTx;
      }, "tag"> & Partial<Pick<{
          oracleTtlType: ORACLE_TTL_TYPES;
      }, never>> & Omit<{
          oracleTtlType: ORACLE_TTL_TYPES;
      }, never> & Partial<Pick<{
          oracleId: `ok_${string}` | `nm_${string}`;
      }, never>> & Omit<{
          oracleId: `ok_${string}` | `nm_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | OracleQueryTx;
      }, "tag">> & Omit<{
          tag: undefined | OracleQueryTx;
      }, "tag"> & Partial<Pick<{
          query: string;
      }, never>> & Omit<{
          query: string;
      }, never> & Partial<Pick<{
          queryTtlType: ORACLE_TTL_TYPES;
      }, never>> & Omit<{
          queryTtlType: ORACLE_TTL_TYPES;
      }, never> & Partial<Pick<{
          queryTtlValue: number;
      }, never>> & Omit<{
          queryTtlValue: number;
      }, never> & Partial<Pick<{
          responseTtlType: ORACLE_TTL_TYPES;
      }, never>> & Omit<{
          responseTtlType: ORACLE_TTL_TYPES;
      }, never> & Partial<Pick<{
          responseTtlValue: number;
      }, never>> & Omit<{
          responseTtlValue: number;
      }, never> & Partial<Pick<{
          tag: undefined | OracleResponseTx;
      }, "tag">> & Omit<{
          tag: undefined | OracleResponseTx;
      }, "tag"> & Partial<Pick<{
          oracleId: `ok_${string}`;
      }, never>> & Omit<{
          oracleId: `ok_${string}`;
      }, never> & Partial<Pick<{
          queryId: `oq_${string}`;
      }, never>> & Omit<{
          queryId: `oq_${string}`;
      }, never> & Partial<Pick<{
          response: string;
      }, never>> & Omit<{
          response: string;
      }, never> & Partial<Pick<{
          tag: undefined | OracleExtendTx;
      }, "tag">> & Omit<{
          tag: undefined | OracleExtendTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | Name;
      }, "tag">> & Omit<{
          tag: undefined | Name;
      }, "tag"> & Partial<Pick<{
          nameTtl: number;
      }, never>> & Omit<{
          nameTtl: number;
      }, never> & Partial<Pick<{
          status: `${any}_${string}`;
      }, never>> & Omit<{
          status: `${any}_${string}`;
      }, never> & Partial<Pick<{
          clientTtl: number;
      }, never>> & Omit<{
          clientTtl: number;
      }, never> & Partial<Pick<{
          pointers: NamePointer[];
      }, never>> & Omit<{
          pointers: NamePointer[];
      }, never> & Partial<Pick<{
          tag: undefined | NameClaimTx;
      }, "tag">> & Omit<{
          tag: undefined | NameClaimTx;
      }, "tag"> & Partial<Pick<{
          name: `${string}.chain`;
      }, never>> & Omit<{
          name: `${string}.chain`;
      }, never> & Partial<Pick<{
          nameSalt: Int;
      }, never>> & Omit<{
          nameSalt: Int;
      }, never> & Partial<Pick<{
          nameFee: undefined | Int;
      }, "nameFee">> & Omit<{
          nameFee: undefined | Int;
      }, "nameFee"> & Partial<Pick<{
          tag: undefined | NamePreclaimTx;
      }, "tag">> & Omit<{
          tag: undefined | NamePreclaimTx;
      }, "tag"> & Partial<Pick<{
          commitmentId: `cm_${string}`;
      }, never>> & Omit<{
          commitmentId: `cm_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | NameUpdateTx;
      }, "tag">> & Omit<{
          tag: undefined | NameUpdateTx;
      }, "tag"> & Partial<Pick<{
          nameId: `${string}.chain` | `nm_${string}`;
      }, never>> & Omit<{
          nameId: `${string}.chain` | `nm_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | NameRevokeTx;
      }, "tag">> & Omit<{
          tag: undefined | NameRevokeTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | NameTransferTx;
      }, "tag">> & Omit<{
          tag: undefined | NameTransferTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | Contract;
      }, "tag">> & Omit<{
          tag: undefined | Contract;
      }, "tag"> & Partial<Pick<{
          owner: `ak_${string}`;
      }, never>> & Omit<{
          owner: `ak_${string}`;
      }, never> & Partial<Pick<{
          ctVersion: CtVersion;
      }, never>> & Omit<{
          ctVersion: CtVersion;
      }, never> & Partial<Pick<{
          code: `cb_${string}`;
      }, never>> & Omit<{
          code: `cb_${string}`;
      }, never> & Partial<Pick<{
          log: `cb_${string}`;
      }, never>> & Omit<{
          log: `cb_${string}`;
      }, never> & Partial<Pick<{
          active: Boolean;
      }, never>> & Omit<{
          active: Boolean;
      }, never> & Partial<Pick<{
          referers: `ak_${string}`[];
      }, never>> & Omit<{
          referers: `ak_${string}`[];
      }, never> & Partial<Pick<{
          deposit: undefined | Int;
      }, "deposit">> & Omit<{
          deposit: undefined | Int;
      }, "deposit"> & Partial<Pick<{
          gasPrice: undefined | Int;
      }, "gasPrice">> & Omit<{
          gasPrice: undefined | Int;
      }, "gasPrice"> & Partial<Pick<{
          callerId: `ak_${string}`;
      }, never>> & Omit<{
          callerId: `ak_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ContractCall;
      }, "tag">> & Omit<{
          tag: undefined | ContractCall;
      }, "tag"> & Partial<Pick<{
          callerNonce: number;
      }, never>> & Omit<{
          callerNonce: number;
      }, never> & Partial<Pick<{
          height: number;
      }, never>> & Omit<{
          height: number;
      }, never> & Partial<Pick<{
          contractId: `ct_${string}`;
      }, never>> & Omit<{
          contractId: `ct_${string}`;
      }, never> & Partial<Pick<{
          gasUsed: number;
      }, never>> & Omit<{
          gasUsed: number;
      }, never> & Partial<Pick<{
          returnValue: `cb_${string}`;
      }, never>> & Omit<{
          returnValue: `cb_${string}`;
      }, never> & Partial<Pick<{
          returnType: CallReturnType;
      }, never>> & Omit<{
          returnType: CallReturnType;
      }, never> & Partial<Pick<{
          log: Uint8Array;
      }, never>> & Omit<{
          log: Uint8Array;
      }, never> & Partial<Pick<{
          tag: undefined | ContractCreateTx;
      }, "tag">> & Omit<{
          tag: undefined | ContractCreateTx;
      }, "tag"> & Partial<Pick<{
          ownerId: `ak_${string}`;
      }, never>> & Omit<{
          ownerId: `ak_${string}`;
      }, never> & Partial<Pick<{
          gasLimit: undefined | number;
      }, "gasLimit">> & Omit<{
          gasLimit: undefined | number;
      }, "gasLimit"> & Partial<Pick<{
          callData: `cb_${string}`;
      }, never>> & Omit<{
          callData: `cb_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ContractCallTx;
      }, "tag">> & Omit<{
          tag: undefined | ContractCallTx;
      }, "tag"> & Partial<Pick<{
          contractId: `ct_${string}` | `nm_${string}`;
      }, never>> & Omit<{
          contractId: `ct_${string}` | `nm_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelCreateTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelCreateTx;
      }, "tag"> & Partial<Pick<{
          initiator: `ak_${string}`;
      }, never>> & Omit<{
          initiator: `ak_${string}`;
      }, never> & Partial<Pick<{
          initiatorAmount: Int;
      }, never>> & Omit<{
          initiatorAmount: Int;
      }, never> & Partial<Pick<{
          responder: `ak_${string}`;
      }, never>> & Omit<{
          responder: `ak_${string}`;
      }, never> & Partial<Pick<{
          responderAmount: Int;
      }, never>> & Omit<{
          responderAmount: Int;
      }, never> & Partial<Pick<{
          channelReserve: Int;
      }, never>> & Omit<{
          channelReserve: Int;
      }, never> & Partial<Pick<{
          lockPeriod: Int;
      }, never>> & Omit<{
          lockPeriod: Int;
      }, never> & Partial<Pick<{
          initiatorDelegateIds: string;
      }, never>> & Omit<{
          initiatorDelegateIds: string;
      }, never> & Partial<Pick<{
          responderDelegateIds: string;
      }, never>> & Omit<{
          responderDelegateIds: string;
      }, never> & Partial<Pick<{
          stateHash: `st_${string}`;
      }, never>> & Omit<{
          stateHash: `st_${string}`;
      }, never> & Partial<Pick<{
          channelId: `ch_${string}`;
      }, never>> & Omit<{
          channelId: `ch_${string}`;
      }, never> & Partial<Pick<{
          fromId: `ak_${string}`;
      }, never>> & Omit<{
          fromId: `ak_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelDepositTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelDepositTx;
      }, "tag"> & Partial<Pick<{
          amount: Int;
      }, never>> & Omit<{
          amount: Int;
      }, never> & Partial<Pick<{
          round: number;
      }, never>> & Omit<{
          round: number;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelWithdrawTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelWithdrawTx;
      }, "tag"> & Partial<Pick<{
          toId: `ak_${string}`;
      }, never>> & Omit<{
          toId: `ak_${string}`;
      }, never> & Partial<Pick<{
          payload: `tx_${string}`;
      }, never>> & Omit<{
          payload: `tx_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelForceProgressTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelForceProgressTx;
      }, "tag"> & Partial<Pick<{
          update: `cb_${string}`;
      }, never>> & Omit<{
          update: `cb_${string}`;
      }, never> & Partial<Pick<{
          offChainTrees: any;
      }, "offChainTrees">> & Omit<{
          offChainTrees: any;
      }, "offChainTrees"> & Partial<Pick<{
          tag: undefined | ChannelCloseMutualTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelCloseMutualTx;
      }, "tag"> & Partial<Pick<{
          initiatorAmountFinal: Int;
      }, never>> & Omit<{
          initiatorAmountFinal: Int;
      }, never> & Partial<Pick<{
          responderAmountFinal: Int;
      }, never>> & Omit<{
          responderAmountFinal: Int;
      }, never> & Partial<Pick<{
          tag: undefined | TreesPoi;
      }, "tag">> & Omit<{
          tag: undefined | TreesPoi;
      }, "tag"> & Partial<Pick<{
          accounts: MPTree<AccountAddress, Account>[];
      }, never>> & Omit<{
          accounts: MPTree<AccountAddress, Account>[];
      }, never> & Partial<Pick<{
          calls: MPTree<Bytearray, ContractCall>[];
      }, never>> & Omit<{
          calls: MPTree<Bytearray, ContractCall>[];
      }, never> & Partial<Pick<{
          channels: MPTree<Channel, Channel>[];
      }, never>> & Omit<{
          channels: MPTree<Channel, Channel>[];
      }, never> & Partial<Pick<{
          contracts: MPTree<ContractAddress, Contract>[];
      }, never>> & Omit<{
          contracts: MPTree<ContractAddress, Contract>[];
      }, never> & Partial<Pick<{
          ns: MPTree<Name, Name>[];
      }, never>> & Omit<{
          ns: MPTree<Name, Name>[];
      }, never> & Partial<Pick<{
          oracles: MPTree<OracleAddress, Oracle>[];
      }, never>> & Omit<{
          oracles: MPTree<OracleAddress, Oracle>[];
      }, never> & Partial<Pick<{
          tag: undefined | ChannelCloseSoloTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelCloseSoloTx;
      }, "tag"> & Partial<Pick<{
          poi: {
              tag: TreesPoi;
              version?: 1;
          } & Omit<Partial<Pick<({ version: 1 | undefined; }), "version">> & Omit<({ version: 1 | undefined; }), "version"> & Partial<Pick<({ tag: Tag.TreesPoi | undefined; }), "tag">> & Omit<({ tag: Tag.TreesPoi | undefined; }), "tag"> & Partial<Pick<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never>> & Omit<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never> & Partial<Pick<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never>> & Omit<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never> & Partial<Pick<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never>> & Omit<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never> & Partial<Pick<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never>> & Omit<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never> & Partial<Pick<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never>> & Omit<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never> & Partial<Pick<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>> & Omit<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>, "version" | "tag">;
      }, never>> & Omit<{
          poi: {
              tag: TreesPoi;
              version?: 1;
          } & Omit<Partial<Pick<({ version: 1 | undefined; }), "version">> & Omit<({ version: 1 | undefined; }), "version"> & Partial<Pick<({ tag: Tag.TreesPoi | undefined; }), "tag">> & Omit<({ tag: Tag.TreesPoi | undefined; }), "tag"> & Partial<Pick<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never>> & Omit<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never> & Partial<Pick<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never>> & Omit<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never> & Partial<Pick<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never>> & Omit<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never> & Partial<Pick<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never>> & Omit<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never> & Partial<Pick<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never>> & Omit<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never> & Partial<Pick<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>> & Omit<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>, "version" | "tag">;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelSlashTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelSlashTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | ChannelSettleTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelSettleTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | ChannelOffChainTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelOffChainTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | ChannelOffChainUpdateTransfer;
      }, "tag">> & Omit<{
          tag: undefined | ChannelOffChainUpdateTransfer;
      }, "tag"> & Partial<Pick<{
          from: `ak_${string}`;
      }, never>> & Omit<{
          from: `ak_${string}`;
      }, never> & Partial<Pick<{
          to: `ak_${string}`;
      }, never>> & Omit<{
          to: `ak_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelOffChainUpdateDeposit;
      }, "tag">> & Omit<{
          tag: undefined | ChannelOffChainUpdateDeposit;
      }, "tag"> & Partial<Pick<{
          tag: undefined | ChannelOffChainUpdateWithdraw;
      }, "tag">> & Omit<{
          tag: undefined | ChannelOffChainUpdateWithdraw;
      }, "tag"> & Partial<Pick<{
          tag: undefined | ChannelOffChainUpdateCreateContract;
      }, "tag">> & Omit<{
          tag: undefined | ChannelOffChainUpdateCreateContract;
      }, "tag"> & Partial<Pick<{
          deposit: Int;
      }, never>> & Omit<{
          deposit: Int;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelOffChainUpdateCallContract;
      }, "tag">> & Omit<{
          tag: undefined | ChannelOffChainUpdateCallContract;
      }, "tag"> & Partial<Pick<{
          caller: `ak_${string}`;
      }, never>> & Omit<{
          caller: `ak_${string}`;
      }, never> & Partial<Pick<{
          contract: `ct_${string}`;
      }, never>> & Omit<{
          contract: `ct_${string}`;
      }, never> & Partial<Pick<{
          callStack: any;
      }, "callStack">> & Omit<{
          callStack: any;
      }, "callStack"> & Partial<Pick<{
          tag: undefined | ChannelClientReconnectTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelClientReconnectTx;
      }, "tag"> & Partial<Pick<{
          role: string;
      }, never>> & Omit<{
          role: string;
      }, never> & Partial<Pick<{
          pubkey: `ak_${string}`;
      }, never>> & Omit<{
          pubkey: `ak_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | Channel;
      }, "tag">> & Omit<{
          tag: undefined | Channel;
      }, "tag"> & Partial<Pick<{
          version: undefined | 3;
      }, "version">> & Omit<{
          version: undefined | 3;
      }, "version"> & Partial<Pick<{
          channelAmount: Int;
      }, never>> & Omit<{
          channelAmount: Int;
      }, never> & Partial<Pick<{
          initiatorDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
      }, never>> & Omit<{
          initiatorDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
      }, never> & Partial<Pick<{
          responderDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
      }, never>> & Omit<{
          responderDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
      }, never> & Partial<Pick<{
          stateHash: string;
      }, never>> & Omit<{
          stateHash: string;
      }, never> & Partial<Pick<{
          soloRound: Int;
      }, never>> & Omit<{
          soloRound: Int;
      }, never> & Partial<Pick<{
          lockedUntil: Int;
      }, never>> & Omit<{
          lockedUntil: Int;
      }, never> & Partial<Pick<{
          initiatorAuth: `cb_${string}`;
      }, never>> & Omit<{
          initiatorAuth: `cb_${string}`;
      }, never> & Partial<Pick<{
          responderAuth: `cb_${string}`;
      }, never>> & Omit<{
          responderAuth: `cb_${string}`;
      }, never> & Partial<Pick<{
          tag: undefined | ChannelSnapshotSoloTx;
      }, "tag">> & Omit<{
          tag: undefined | ChannelSnapshotSoloTx;
      }, "tag"> & Partial<Pick<{
          tag: undefined | StateTrees;
      }, "tag">> & Omit<{
          tag: undefined | StateTrees;
      }, "tag"> & Partial<Pick<{
          contracts: any;
      }, "contracts">> & Omit<{
          contracts: any;
      }, "contracts"> & Partial<Pick<{
          calls: any;
      }, "calls">> & Omit<{
          calls: any;
      }, "calls"> & Partial<Pick<{
          channels: any;
      }, "channels">> & Omit<{
          channels: any;
      }, "channels"> & Partial<Pick<{
          ns: any;
      }, "ns">> & Omit<{
          ns: any;
      }, "ns"> & Partial<Pick<{
          oracles: any;
      }, "oracles">> & Omit<{
          oracles: any;
      }, "oracles"> & Partial<Pick<{
          accounts: any;
      }, "accounts">> & Omit<{
          accounts: any;
      }, "accounts"> & Partial<Pick<{
          tag: undefined | Mtree;
      }, "tag">> & Omit<{
          tag: undefined | Mtree;
      }, "tag"> & Partial<Pick<{
          values: any[];
      }, never>> & Omit<{
          values: any[];
      }, never> & Partial<Pick<{
          tag: undefined | MtreeValue;
      }, "tag">> & Omit<{
          tag: undefined | MtreeValue;
      }, "tag"> & Partial<Pick<{
          key: string;
      }, never>> & Omit<{
          key: string;
      }, never> & Partial<Pick<{
          value: Uint8Array;
      }, never>> & Omit<{
          value: Uint8Array;
      }, never> & Partial<Pick<{
          tag: undefined | ContractsMtree;
      }, "tag">> & Omit<{
          tag: undefined | ContractsMtree;
      }, "tag"> & Partial<Pick<{
          tag: undefined | CallsMtree;
      }, "tag">> & Omit<{
          tag: undefined | CallsMtree;
      }, "tag"> & Partial<Pick<{
          tag: undefined | ChannelsMtree;
      }, "tag">> & Omit<{
          tag: undefined | ChannelsMtree;
      }, "tag"> & Partial<Pick<{
          tag: undefined | NameserviceMtree;
      }, "tag">> & Omit<{
          tag: undefined | NameserviceMtree;
      }, "tag"> & Partial<Pick<{
          mtree: any;
      }, "mtree">> & Omit<{
          mtree: any;
      }, "mtree"> & Partial<Pick<{
          tag: undefined | OraclesMtree;
      }, "tag">> & Omit<{
          tag: undefined | OraclesMtree;
      }, "tag"> & Partial<Pick<{
          otree: any;
      }, "otree">> & Omit<{
          otree: any;
      }, "otree"> & Partial<Pick<{
          tag: undefined | AccountsMtree;
      }, "tag">> & Omit<{
          tag: undefined | AccountsMtree;
      }, "tag"> & Partial<Pick<{
          tag: undefined | CompilerSophia;
      }, "tag">> & Omit<{
          tag: undefined | CompilerSophia;
      }, "tag"> & Partial<Pick<{
          sourceCodeHash: Uint8Array;
      }, never>> & Omit<{
          sourceCodeHash: Uint8Array;
      }, never> & Partial<Pick<{
          typeInfo: any;
      }, "typeInfo">> & Omit<{
          typeInfo: any;
      }, "typeInfo"> & Partial<Pick<{
          byteCode: Uint8Array;
      }, never>> & Omit<{
          byteCode: Uint8Array;
      }, never> & Partial<Pick<{
          compilerVersion: string;
      }, never>> & Omit<{
          compilerVersion: string;
      }, never> & Partial<Pick<{
          payable: Boolean;
      }, never>> & Omit<{
          payable: Boolean;
      }, never> & Partial<Pick<{
          tag: undefined | GaAttachTx;
      }, "tag">> & Omit<{
          tag: undefined | GaAttachTx;
      }, "tag"> & Partial<Pick<{
          authFun: Uint8Array;
      }, never>> & Omit<{
          authFun: Uint8Array;
      }, never> & Partial<Pick<{
          tag: undefined | GaMetaTx;
      }, "tag">> & Omit<{
          tag: undefined | GaMetaTx;
      }, "tag"> & Partial<Pick<{
          gaId: `ak_${string}`;
      }, never>> & Omit<{
          gaId: `ak_${string}`;
      }, never> & Partial<Pick<{
          authData: `cb_${string}`;
      }, never>> & Omit<{
          authData: `cb_${string}`;
      }, never> & Partial<Pick<{
          tx: any;
      }, "tx">> & Omit<{
          tx: any;
      }, "tx"> & Partial<Pick<{
          tag: undefined | PayingForTx;
      }, "tag">> & Omit<{
          tag: undefined | PayingForTx;
      }, "tag"> & Partial<Pick<{
          payerId: `ak_${string}`;
      }, never>> & Omit<{
          payerId: `ak_${string}`;
      }, never>>, "nonce" | "ttl">, "senderId"> & (TxType extends OracleResponseTx | OracleExtendTx ? {
          callerId: `ak_${string}`;
      } : {}) & (TxType extends ContractCreateTx | GaAttachTx ? {
          ctVersion?: CtVersion;
      } : {}) & (TxType extends OracleRegisterTx | ContractCallTx ? {
          abiVersion?: ABI_VERSIONS;
      } : {}), "onNode"> & {
          onNode?: Node;
      }

    Returns Promise<`tx_${string}`>

Protected ensureNodeConnected

getAccounts

  • Get Wallet accounts

    Returns

    Object with accounts information ({ connected: Object, current: Object })

    Returns Accounts

getNodeInfo

getNodesInPool

getWalletInfo

initializeContract

  • Type Parameters

    Parameters

    • Optional options: Omit<Omit<{
          aci: Aci;
          address?: `ct_${string}`;
          bytecode?: `cb_${string}`;
          fileSystem?: Record<string, string>;
          onCompiler?: CompilerBase;
          onNode: Node;
          sourceCode?: string;
          sourceCodePath?: string;
      } & Partial<BuildTxOptions<ContractCallTx, "callData" | "callerId" | "contractId">> & {
          omitUnknown?: boolean;
      } & {
          contractAddressToName?: {
              [key: ContractAddress]: string;
          };
      } & Omit<SendOptions, "onNode" | "onAccount"> & Omit<{
          combine?: boolean;
          onNode: Node;
          top?: number | `kh_${string}` | `mh_${string}`;
          txEvents?: boolean;
      }, "onNode"> & {
          callStatic?: boolean;
          onAccount?: AccountBase;
          onNode?: Node;
      } & Partial<BuildTxOptions<ContractCreateTx, "code" | "ownerId" | "callData">>, "address" | "aci"> & {
          aci?: Aci;
          address?: `${string}.chain` | `ct_${string}`;
          validateBytecode?: boolean;
      }, "onNode"> & {
          onNode?: Node;
      }

    Returns Promise<Contract<Methods>>

isNodeConnected

  • Check if you have selected node

    Example

    nodePool.isNodeConnected()

    Returns this is AeSdkBase & {
        selectedNodeName: string;
    }

removeAccount

  • Remove specific account

    Example

    removeAccount(address)

    Parameters

    • address: `ak_${string}`

      Address of account to remove

    Returns void

removeRpcClient

  • Remove specific RpcClient by ID

    Parameters

    • id: string

      Client ID

    Returns void

selectAccount

  • Select specific account

    Example

    selectAccount('ak_xxxxxxxx')

    Parameters

    • address: `ak_${string}`

      Address of account to select

    Returns void

selectNode

  • Select Node

    Example

    nodePool.selectNode('testNode')

    Parameters

    • name: string

      Node name

    Returns Promise<void>

shareWalletInfo

  • Send shareWalletInfo message to notify AEPP about wallet

    Parameters

    • clientId: string

      ID of RPC client send message to

    Returns Promise<void>

sign

  • Parameters

    • data: string | Uint8Array
    • __namedParameters: {
          onAccount?: OnAccount;
      } = {}

    Returns Promise<Uint8Array>

signMessage

  • Parameters

    • message: string
    • __namedParameters: {
          onAccount?: OnAccount;
      } & {
          aeppOrigin?: string;
          aeppRpcClientId?: string;
      } = {}

    Returns Promise<Uint8Array>

signTransaction

  • Parameters

    • tx: `tx_${string}`
    • __namedParameters: {
          onAccount?: OnAccount;
      } & {
          aeppOrigin?: string;
          aeppRpcClientId?: string;
          authData?: {
              args?: any[];
              callData?: `cb_${string}`;
              gasLimit?: number;
              sourceCode?: string;
          };
          innerTx?: boolean;
          networkId?: string;
          onCompiler?: CompilerBase;
          onNode?: Node;
      } = {}

    Returns Promise<`tx_${string}`>

Settings

Member Visibility

Theme

Generated using TypeDoc